Hvordan sletter jeg en Git-filial lokalt og eksternt?

1
2
Neste
Kortfattet sammendrag
$ git push -d  
$ git branch -d 
Vær oppmerksom på at fjernnavnet i de fleste tilfeller er opprinnelse.
I et slikt tilfelle må du bruke kommandoen slik.
$ git push -d origin 
Slett lokal filial
For å slette den lokale avdelingen, bruk ett av følgende:
$ git branch -d branch_name
$ git branch -D branch_name
Merk: Alternativet -d er et alias for --delete, som bare sletter grenen hvis den allerede er helt slått sammen i oppstrømsgrenen. Du kan også bruke -D, som er et alias for --delete --force, som sletter grenen "uavhengig av sammenslått status." [Kilde: man git-branch]
Vær også oppmerksom på at git branch -d branch_name mislykkes hvis du er for øyeblikket
i grenen du vil fjerne. Meldingen starter med
feil: Kan ikke slette grenen 'filialnavn'. I så fall bytter du først
til en annen gren, for eksempel: git checkout master.
Slett ekstern filial [Oppdatert 8. september 2017]
Fra og med Git v1.7.0 kan du slette en ekstern gren ved hjelp av
$ git push  - slett 
som kan være lettere å huske enn
$ git push : 
som ble lagt til i Git v1.5.0 "for å slette en ekstern gren eller en tag."
Fra og med Git v2.8.0 kan du også bruke git push med alternativet -d som et alias for --delete.
Derfor vil versjonen av Git du har installert diktere om du trenger å bruke den enklere eller hardere syntaksen.
Slett ekstern filial [Originalt svar fra 5. januar 2010]
Fra kapittel 3 i Pro Git av Scott Chacon:
Slette eksterne filialer
Anta at du er ferdig med en ekstern gren - si at du og dine samarbeidspartnere er ferdige med en funksjon og har slått den sammen til fjernkontrollens hovedfilial (eller hvilken gren som din stabile kodelinje er i). Du kan slette en ekstern gren ved å bruke den ganske stumme syntaksen git push [fjernnavn]: [gren]. Hvis du vil slette din server-fix gren fra serveren, kjører du følgende:
$ git push opprinnelse: serverfix
Til git@github.com: schacon / simplegit.git
- [slettet] serverfix
Boom. Ingen flere filialer på serveren din. Det kan være lurt å lytte til denne siden fordi du trenger den kommandoen, og du vil sannsynligvis glemme syntaksen. En måte å huske denne kommandoen på er å huske git push [remotename] [localbranch]: [remotebranch] syntaks som vi gikk over litt tidligere. Hvis du slutter med [localbranch] -delen, så sier du i utgangspunktet: "Ta ingenting på min side og gjør det til [remotebranch]."
Jeg utstedte git push-opprinnelse: bugfix og det fungerte vakkert. Scott Chacon hadde rett - jeg vil ønske å øre den siden (eller nesten hunden øre ved å svare på dette på Stack Overflow).
Så bør du utføre dette på andre maskiner
# Hent endringer fra alle fjernkontroller og slett lokalt
# fjerntliggende slettede grener / tagger osv
# - beskjære vil gjøre jobben: -;
git henting - alt - beskjære
å forplante endringer.
|
Matthews svar er flott for å fjerne eksterne grener, og jeg setter også pris på forklaringen, men for å gjøre et enkelt skille mellom de to kommandoene:
Slik fjerner du en lokal filial fra maskinen din:
git branch -d {the_local_branch} (bruk -D i stedet for å tvinge sletting av grenen uten å sjekke sammenslått status)
Slik fjerner du en ekstern gren fra serveren:
git push origin - slett {the_remote_branch}
Referanse: Git: Slett en gren (lokal eller ekstern)
|
De korte svarene
Hvis du vil ha mer detaljerte forklaringer på følgende kommandoer, kan du se de lange svarene i neste avsnitt.
Slette en ekstern gren
git push origin --delete  # Git versjon 1.7.0 eller nyere
git push origin -d  # Kortere versjon (Git 1.7.0 eller nyere)
git push origin:  # Git-versjoner eldre enn 1.7.0
Slette en lokal filial
git branch --delete 
git branch -d  # Kortere versjon
git branch -D  # Tving-slett ikke-sammenslåtte grener
Slette en lokal fil for ekstern sporing
git gren --delete - fjernkontroller  / 
git branch -dr  /  # Kortere
git fetch  --prune # Slett flere foreldede fjernsporingsgrener
git hent  -p # Kortere
Det lange svaret: det er tre forskjellige grener å slette!
Når du har å gjøre med å slette filialer både lokalt og eksternt, må du huske at det er tre forskjellige grener involvert:
Lokalgrenen X.
Den fjerne opprinnelsesgrenen X.
Den lokale fjernsporingsgrenens opprinnelse / X som sporer den eksterne grenen X.
Den opprinnelige plakaten som ble brukt:
git branch -rd origin / bugfix
Som bare slettet den lokale fjernsporing av grenens opprinnelse / bugfix, og ikke den faktiske eksterne grenens bugfix på opprinnelsen.
For å slette den faktiske eksterne grenen, trenger du
git push origin - slett feilretting
Ekstra detaljer
De følgende avsnittene beskriver ytterligere detaljer som du må ta hensyn til når du sletter fjernkontroll- og fjernsporingsgrener.
Hvis du skyver for å slette eksterne grener, fjernes også grener som fjernsporer
Merk at du sletter den eksterne grenen X fra kommandolinjenved å bruke en git push fjernes også den lokale fjernsporingsgrenens opprinnelse / X, så det er ikke nødvendig å beskjære den foreldede fjernsporingsgrenen med git fetch --prune eller git fetch -p. Det ville imidlertid ikke skade hvis du gjorde det uansett.
Du kan bekrefte at fjernsporingsgrenens opprinnelse / X også ble slettet ved å kjøre følgende:
# Se bare fjernsporing av grener
git gren - fjernkontroller
git gren -r
# Se både strengt lokale så vel som fjernsporende grener
git gren - alt
git gren -a
Beskjæring av det foreldede lokale fjernsporingsgrenens opprinnelse / X
Hvis du ikke slettet den eksterne grenen X fra kommandolinjen (som ovenfor), vil det lokale depotet ditt fremdeles inneholde (et nå utdatert) fjernsporende grenopprinnelse / X. Dette kan skje hvis du for eksempel slettet en ekstern gren direkte gjennom GitHubs nettgrensesnitt.
En typisk måte å fjerne disse foreldede fjernsporingsgrenene på (siden Git versjon 1.6.6) er å bare kjøre git-henting med --prune eller kortere -p. Merk at dette fjerner alle foreldede lokale fjernsporingsgrener for eventuelle eksterne grener som ikke lenger eksisterer på fjernkontrollen:
git hent opprinnelse - beskjære
git hente opprinnelse -p # Kortere
Her er det relevante sitatet fra 1.6.6 utgivelsesnotater (vektlegging min):
"git fetch" lærte - alle og - flere valg, å kjøre henting fra
mange arkiver, og --prune-alternativet for å fjerne ekstern sporing
grener som ble foreldede. Disse lager "git remote update" og "git
ekstern beskjæring "mindre nødvendig (det er ingen plan for å fjerne" fjernkontroll
oppdater "eller" ekstern beskjæring ", skjønt).
Alternativ til automatisk beskjæring ovenfor for foreldede fjernsporingsgrener
Alternativt, i stedet for å beskjære dine foreldede lokale fjernsporingsgrener gjennom git fetch -p, kan du unngå å utføre den ekstra nettverksoperasjonen ved å bare fjerne grenen manuelt med flaggene --remote eller -r:
git gren --delete - fjern opprinnelse / X
git gren -dr opprinnelse / X # kortere
Se også
git-branch (1) Manuell side.
git-fetch (1) Manuell side.
Pro Git § 3.5 Git Branching - Remote Branches.
|
Fremgangsmåte for å slette en filial:
For å slette den eksterne grenen:
git push origin - slett 
For å slette den lokale avdelingen har du tre måter:
1: git gren -D 
2: git-gren --delete --force  # Samme som -D
3: git-gren - slett  # Feil ved fletting
Forklar: OK, bare forklar hva som skjer her!
Bare gjør git push origin - slett bare for å slette den eksterne grenen, legg til navnet på grenen på slutten, og dette vil slette og skyve den til fjernkontrollen samtidig ...
Også git gren -D, som bare sletter den lokale grenen! ...
-D står for --delete - force som vil slette grenen selv om den ikke er slått sammen (force delete), men du kan også bruke -d som står for --delete som kaster en feil i henhold til grenens flettestatus ...
Jeg oppretter også bildet nedenfor for å vise trinnene:
|
Du kan også bruke følgende for å slette den eksterne grenen
git push - slett opprinnelse serverfix
Som gjør det samme som
git push origin: serverfix
men det kan være lettere å huske.
|
Tips: Når du sletter grener ved hjelp av
git branch -d  # Sletter lokal filial
eller
git push origin:  # Sletter ekstern gren
bare referansene slettes. Selv om filialen faktisk er fjernet på fjernkontrollen, finnes referansene til den fremdeles i de lokale arkivene til teammedlemmene dine. Dette betyr at for andre teammedlemmer er de slettede grenene fremdeles synlige når de gjør en git-gren.
For å løse dette kan teammedlemmene beskjære de slettede grenene med
git ekstern beskjæring 
Dette er vanligvis git ekstern beskjæringsopprinnelse.
|
Hvis du vil slette en gren, må du først sjekke ut til den andre grenen enn grenen som skal slettes.
git checkout other_than_branch_to_be_deleted
Slette den lokale avdelingen:
git branch -D branch_to_be_deleted
Slette den eksterne grenen:
git push origin - slett gren_til_slett
|
git gren -D 
git gren -D -r opprinnelse / 
git push opprinnelse: 
|
Dette er enkelt: Bare kjør følgende kommando:
For å slette en Git-gren både lokalt og eksternt, slett først den lokale grenen ved hjelp av denne kommandoen:
git gren -d eksempel
(Dette eksemplet er grennavnet.)
Og etter det, slett den eksterne grenen ved hjelp av denne kommandoen:
git push origin: eksempel
|
Det er veldig enkelt:
For å slette den eksterne grenen
git push -d origin 
Eller
git push origin: 
For å slette den lokale avdelingen med kraft
git branch -D 
|
En annen tilnærming er:
git push - beskjære opprinnelse
ADVARSEL: Dette vil slette alle eksterne grener som ikke eksisterer lokalt. Eller mer omfattende,
git push - speil
vil effektivt få fjernregisteret til å se ut som den lokale kopien av depotet (lokale hoder, fjernkontroller og koder speiles på fjernkontrollen).
|
Jeg bruker følgende i mine Bash-innstillinger:
alias git-shoot = "git pushopprinnelse - slett "
Da kan du ringe:
git-shoot grennavn
|
Slett lokalt:
For å slette en lokal filial kan du bruke:
git branch -d 
For å slette en gren med makt, bruk -D i stedet for -d.
git branch -D 
Slett eksternt:
Det er to alternativer:
git push opprinnelse: grennavn
git push origin - slett filialnavn
Jeg vil foreslå at du bruker den andre måten, da det er mer intuitivt.
|
Siden januar 2013 inkluderte GitHub en Slett gren-knapp ved siden av hver gren i "Grener" -siden.
Relevant blogginnlegg: Opprett og slett grener
|
Hvis du vil fullføre begge disse trinnene med en enkelt kommando, kan du lage et alias for det ved å legge til nedenfor i ~ / .gitconfig:
[alias]
rmbranch = "! f () {git branch -d $ {1} && git push origin --delete $ {1};}; f"
Alternativt kan du legge til dette i din globale konfigurasjon fra kommandolinjen ved hjelp av
git config --global alias.rmbranch \
'! f () {git branch -d $ {1} && git push origin --delete $ {1}; }; f '
MERKNAD: Hvis du bruker -d (små bokstaver d), blir grenen bare slettet hvis den er slått sammen. For å tvinge slettingen til å skje, må du bruke -D (store bokstaver D).
|
For å slette filialen din lokalt og eksternt
Kasse til mastergren - git checkout master
Slett den eksterne grenen - git push origin - slett 
Slett din lokale filial - git gren - slett 
|
Du kan også gjøre dette ved hjelp av git ekstern beskjæringsopprinnelse
$ git ekstern beskjæringsopprinnelse
Beskjæring av opprinnelse
URL: git@example.com/yourrepo.git
* [beskåret] opprinnelse / noen grener
Det beskjærer og sletter fjernsporende grener fra en git-gren -r-oppføring.
|
I tillegg til de andre svarene bruker jeg ofte verktøyet git_remote_branch. Det er en ekstra installasjon, men det gir deg en praktisk måte å samhandle med eksterne grener. I dette tilfellet, for å slette:
grb slette gren
Jeg opplever at jeg også bruker publiserings- og sporkommandoene ganske ofte.
|
En one-liner-kommando for å slette både lokal og ekstern:
D = gren-navn; git gren -D $ D; git push opprinnelse: $ D
Eller legg til aliaset nedenfor i ~ / .gitconfig. Bruk: git kill gren-name
[alias]
kill = "! f () {git branch -D \" $ 1 \ "; git push origin --delete \" $ 1 \ ";}; f"
|
Slette filialer
La oss anta at arbeidet vårt med "kontaktform" er fullført, og at vi allerede har integrert det i "master". Siden vi ikke trenger det lenger, kan vi slette det (lokalt):
$ git gren -d kontaktskjema
Og for å slette den eksterne grenen:
git push origin - slett kontaktskjema
|
Slett ekstern gren
git push origin: 
Slett lokal filial
git branch -D 
Slett trinn for lokal filial:
kassen til en annen gren
slett lokal filial
|
Bare si:
git branch -d 
git push origin: 
|
git push origin --delete 
er lettere å huske enn
git push origin: branchName
|
Nå kan du gjøre det med GitHub Desktop-applikasjonen.
Etter at du har startet applikasjonen
Klikk på prosjektet som inneholder grenen
Bytt til grenen du vil slette
Fra "Branch" -menyen velger du "Unpublish ..." for å få grenen slettet fra GitHub-serverne.
Fra "Gren" -menyen, velg "Slett" grennavn "..." for å få filialen slettet av din lokale maskin (AKA maskinen du jobber med for tiden)
|
Slette lokalt - (normalt)
git branch -d my_branch
Hvis filialen din er i en ombyggings- / sammenslåingsprosess og det ikke ble gjort riktig, betyr det at du vil få en feil, Rebase / Merge pågår, så i så fall vil du ikke kunne slette filialen din.
Så enten må du løse omgraderingen / sammenslåingen. Ellers kan du tvinge sletting ved å bruke,
git branch -D my_branch
Slik sletter du på fjernkontrollen:
git push - slett opprinnelse my_branch
Du kan gjøre det samme ved å bruke:
git push origin: my_branch # Lett å huske begge vil gjøre det samme.
Grafisk representasjon:
|
Dette fungerer ikke hvis du har en tag med samme navn som grenen på fjernkontrollen:
$ git push origin: gren-eller-tag-navn
feil: dst refspec gren-eller-tag-navn samsvarer med mer enn en.
feil: klarte ikke å skyve noen refs til 'git@github.com: SomeName / some-repo.git'
I så fall må du spesifisere at du vil slette grenen, ikke koden:
git push origin: refs / heads / branch-or-tag-name
På samme måte, for å slette koden i stedet for grenen, vil du bruke:
git push origin: refs / tags / branch-or-tag-name
|
Mange av de andre svarene vil føre til feil / advarsler. Denne tilnærmingen er relativt idiotsikker, selv om du fremdeles kan trenge git branch -D branch_to_delete hvis den ikke er helt sammenslått i noen_other_branch.
git checkout some_other_branch
git push origin: branch_to_delete
git branch -d branch_to_delete
Ekstern beskjæring er ikke nødvendig hvis du slettet den eksterne grenen. Det brukes bare for å få de mest oppdaterte fjernkontrollene som er tilgjengelige på et depot du sporer. Jeg har observert at git-henting vil legge til fjernkontroller, ikke fjerne dem. Her er et eksempel på når git ekstern beskjæringsopprinnelse faktisk vil gjøre noe:
Bruker Agjør trinnene ovenfor. Bruker B vil kjøre følgende kommandoer for å se de mest oppdaterte eksterne grenene:
git-henting
git ekstern beskjæringsopprinnelse
git gren -r
|
Jeg ble lei av googling for dette svaret, så jeg tok en lignende tilnærming til svaret som crizCraig la ut tidligere.
Jeg la til følgende i Bash-profilen min:
funksjon gitdelete () {
git push origin - slett $ 1
git gren -D $ 1
}
Hver gang jeg er ferdig med en gren (for eksempel fusjonert til master), kjører jeg følgende i terminalen min:
gitdelete my-branch-name
... som deretter sletter mitt filialnavn fra opprinnelse så vel som lokalt.
|
Før du utfører
git branch --delete 
sørg for at du først avgjør hva det eksakte navnet på den eksterne grenen er ved å utføre:
git ls-fjernkontroll
Dette vil fortelle deg hva du skal angi nøyaktig for  -verdien. (gren er skift mellom store og små bokstaver!)
|
Bruk:
git push origin: bugfix # Sletter ekstern gren
git branch -d bugfix # Må slette lokal filial manuelt
Hvis du er sikker på at du vil slette den, kjører du
git branch -D bugfix
Nå for å rydde opp slettede eksterne grener kjøres
git ekstern beskjæringsopprinnelse
|
1
2
Neste
Svært aktivt spørsmål. Tjen 10 rykte for å svare på dette spørsmålet. Omdømmekravet hjelper deg med å beskytte dette spørsmålet mot spam og ikke-svar-aktivitet.
Er ikke svaret du leter etter? Bla gjennom andre spørsmål merket git versjonskontroll git-branch git-push git-remote eller still ditt eget spørsmål.